package newx.utils
{
	import newx.com.config.StaticIni;

	public class ArrayUtils
	{
		public function ArrayUtils()
		{
		}
		
		//删除相同的元素
		public static function DeleteSameItems(val:Array):void
		{
			//以元素为下标创建一个数组，假如元素类型限制不能做下标，这个算法就没用了，自己重写吧
			var	tempArr:Array	=	new Array();
			var	len:int			=	val.length;
			//指向存数据的地方
			var	i:int			=	0;
			//指向取数据的地方
			var j:int			=	0;
			
			//一直做到数组结束
			while(val[i] != undefined)
			{
				while(undefined != tempArr[val[i]])
				{
					//假如新数组中有，肯定重复了，把后面的移上来
					val[i]	= val[j+1];					
					//取数据的地方加一
					j++;
				}
				
				//给下个位置取个数据
				if(j > i)
				{
					val[i + 1] = val[++j];
				}
				else
				{
					j = i;
				}
				tempArr[val[i]]	=	true;
				i++;				
			};
			val.length	=	i;
		}
		
		//删除一个指定元素,后面元素接上
		public static function DeleteItem(arr:Array,val:*):void
		{
			var	index:int	=	arr.indexOf(val);
			arr.splice(index,1);
		}
		
		//删除一些元素,后面元素接上
		public static function DeleteItems(arr:Array,vals:Array):void
		{
			var	i:int	=	0;
			while(i < vals.length)
			{
				var	index:int	=	arr.indexOf(vals[i]);
				
				if(-1 != index)
				{
					arr.splice(index,1);
				}
				
				i++;
			}
		}
		
//		/**
//		 * 判断连个数组是否相等，只判断一级 
//		 * @param val1
//		 * @param val2
//		 * @return 
//		 * 
//		 */		
//		public static function isSame(val1:Array,val2:Array):Boolean
//		{
//			if(val1 == null && val2 == null)
//			{
//				return true;
//			}
//			else if(val1 != null && val2 != null)
//			{
//				return false;
//			}
//			else
//			{
//				var tSize:int	=	val1.length;
//				if(tSize != val2.length)
//				{
//					return false;
//				}
//				
//				for(var i:int = 0 ; i < tSize ; i ++)
//				{
//					if(val1[i] != val2[i])
//					{
//						return false;
//					}
//				}
//				return true;
//			}
//			
//		}
		
		/**
		 * 以快速排序的方式排列数组
		 * @param pData		：数组
		 * @param keyIndex	：用于定位数组中的那些元素是用于比较的
		 * @param sortType	：排序类型，默认升序。
		 * 
		 */		
		public static function QuickSortPlanar(arr:Array,keyIndex:*,sortType:int = 0):void
		{
			if(arr.length>0)
			{
				//用于比较大小的函数
				var funcMore	:Function	=	function More(
					a:Array,b:Array):Boolean
				{
					return a[keyIndex]  >  b[keyIndex];
				};
				
				var funcEqual	:Function	=	function Equal(
					a:Array,b:Array):Boolean
				{
					return a[keyIndex]  ==  b[keyIndex];
				};
				
				var funcLess	:Function	=	function Less(
					a:Array,b:Array):Boolean
				{
					return a[keyIndex]  <  b[keyIndex];
				};
				
				var QuickSort:Function	=	function QuickSort(
					pData	:Array,
					more	:Function,
					equal	:Function,
					less	:Function,
					left	:int,
					right	:int):void
				{
					
					var i:int		= left;
					var j:int		= right;
					var middle:*;
					var iTemp:*;
					
					middle = pData[Math.floor((left+right)/2.0)];//求中间值
					//middle = pData[((Math.random() * 65535)%(right-left+1))+left]; //生成大于等于left小于等于right的随机数
					
					do{
						while(less(pData[i],middle) && (i<right))//从左扫描大于中值的数
							i++;
						while(more(pData[j],middle) && (j>left))//从右扫描小于中值的数
							j--;
						//找到了一对值,交换
						if(i<=j)
						{
							if(!equal(pData[i],pData[j]))
							{
								iTemp=pData[j];					
								pData[j]=pData[i];					
								pData[i]=iTemp;	
							}									
							i++;					
							j--;					
						}
					}while(i<=j);//如果两边扫描的下标交错，就停止（完成一次）
					//当左边部分有值(left<j)，递归左半边			
					if(left<j){				
						QuickSort(pData,more,equal,less,left,j);				
					}			
					//当右边部分有值(right>i)，递归右半边			
					if(right>i){				
						QuickSort(pData,more,equal,less,i,right);				
					}			
				};
				
				//启动递归
				QuickSort(arr,							
					(sortType == 0)?funcMore:funcLess,
					funcEqual,
					(sortType == 0)?funcLess:funcMore,
					0,arr.length - 1);
			}
		}
	}
}